lion@lion-tp:~/code/chainsafe/lodestar$ git diff
diff --git a/packages/beacon-node/src/chain/prepareNextSlot.ts b/packages/beacon-node/src/chain/prepareNextSlot.ts
index 42003052da..34e91bbc1f 100644
--- a/packages/beacon-node/src/chain/prepareNextSlot.ts
+++ b/packages/beacon-node/src/chain/prepareNextSlot.ts
@@ -84,6 +84,9 @@ export class PrepareNextSlotScheduler {
           clockSlot,
         });
         // It's important to still do this to get through Holesky unfinality time of low resouce nodes
+        // This sentence needs much more context, just saying it's important is not enough. Link to an issue or
+        // PR with the full context and summarize in 1 sentence here. Explain why this function appears two
+        // times in the same function.
         await this.prunePerSlot(clockSlot);
         return;
       }
@@ -176,6 +179,9 @@ export class PrepareNextSlotScheduler {
       }
 
       // do this after all as it's the lowest priority task
+      // LION: Calling this function does not have anything to do really with "prepareNextSlot". The scope creep of this function
+      // is bad, basically being a dump of every action that must be performed routinely of-slot. This class a whole is kind of
+      // useless it holds no state, and just subscribes to an event to run this function.
       await this.prunePerSlot(clockSlot);
     } catch (e) {
       if (!isErrorAborted(e) && !isQueueErrorAborted(e)) {
@@ -191,10 +197,12 @@ export class PrepareNextSlotScheduler {
    * However, it's not likely `inMemoryEpochs` is configured as 0, and this scenario rarely happen
    * since we only use `inMemoryEpochs = 0` for testing, if it happens it's a good thing because it helps us test the reload flow
    */
+  // This function only prunes checkpointStates, call it pruneCheckpointStateCache, rename to a generic "pruneX" latter when multiuse
   private prunePerSlot = async (clockSlot: Slot): Promise<void> => {
     // a contabo vpss can have 10-12 holesky epoch transitions per epoch when syncing, stronger node may have more
     // it's better to prune at the last 1/3 of every slot in order not to cache a lot of checkpoint states
     // at synced time, it's likely we only prune at the 1st slot of epoch, all other prunes are no-op
+    // LION: Where do you enfore that this function runs on the 1/3 of the slot?
     const pruneCount = await this.chain.regen.pruneCheckpointStateCache();
     this.logger.verbose("Pruned checkpoint state cache", {clockSlot, pruneCount});
   };
diff --git a/packages/beacon-node/src/chain/stateCache/persistentCheckpointsCache.ts b/packages/beacon-node/src/chain/stateCache/persistentCheckpointsCache.ts
index 7ddf57eb2b..5f9b43799a 100644
--- a/packages/beacon-node/src/chain/stateCache/persistentCheckpointsCache.ts
+++ b/packages/beacon-node/src/chain/stateCache/persistentCheckpointsCache.ts
@@ -143,10 +143,13 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
       this.logger.verbose("Reload: read state failed", {persistentKey});
       return null;
     }
+    // Add white space to this function, space code out with comments where necessary
     this.logger.verbose("Reload: read state successfully", {persistentKey});
     this.metrics?.stateRemoveCount.inc({reason: RemovePersistedStateReason.reload});
+    // Why is the clock maybe nullish? Why does it use the current slot? If some value is nullish, what's the point of observing zero?
     this.metrics?.stateReloadSecFromSlot.observe(this.clock?.secFromSlot(this.clock?.currentSlot ?? 0) ?? 0);
     const closestState = findClosestCheckpointState(cp, this.cache) ?? this.getHeadState?.();
+    // Is this a possible state? If getHeadState always return a value, not
     if (closestState == null) {
       throw new Error("No closest state found for cp " + toCheckpointKey(cp));
     }
@@ -171,6 +174,9 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
       // don't prune from memory here, call it at the last 1/3 of slot 0 of an epoch
       return newCachedState;
     } catch (e) {
+      // This is not true, and this broad try catch for so many different steps is very bad.
+      // There should probably not be a try catch here at all. If it must be, do something meaningful,
+      // and wrap individual steps. Not all code from `loadCachedBeaconState` until end of function.
       this.logger.debug("Error reloading state from disk", {persistentKey}, e as Error);
       return null;
     }
@@ -279,6 +285,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
     // sort epochs in descending order, only consider epochs lte `epoch`
     const epochs = Array.from(this.epochIndex.keys())
       .sort((a, b) => b - a)
+    // filter first
       .filter((e) => e <= maxEpoch);
     for (const epoch of epochs) {
       if (this.epochIndex.get(epoch)?.has(rootHex)) {
@@ -288,6 +295,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
             return state;
           }
         } catch (e) {
+          // Why would this fail? Blind try catches are not okay
           this.logger.debug("Error get or reload state", {epoch, rootHex}, e as Error);
         }
       }
@@ -316,6 +324,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   pruneFinalized(finalizedEpoch: Epoch): void {
     for (const epoch of this.epochIndex.keys()) {
       if (epoch < finalizedEpoch) {
+        // This can overwhelm the underlying persistent API by requesting many delete operations at once
         this.deleteAllEpochItems(epoch).catch((e) =>
           this.logger.debug("Error delete all epoch items", {epoch, finalizedEpoch}, e as Error)
         );
@@ -385,6 +394,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
       }
       if (firstEpoch === undefined) {
         // should not happen
+        // LION: why not? explain
         throw new Error("No epoch in memory");
       }
       // first loop to check if the 1st slot of epoch is a skipped slot or not
@@ -408,6 +418,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
       // if not found firstSlotBlockRoot, first slot of state is skipped, we should persist the Previous Root Checkpoint State, where the root
       // is the last block slot root of pervious epoch. In this case Previous Root Checkpoint State would become the justified/finalized state.
       for (const rootHex of this.epochIndex.get(firstEpoch) ?? []) {
+        // rewrite this with direct assignments to toPersist and toDelete, no let
         let toPersist = false;
         let toDelete = false;
         if (firstSlotBlockRoot === undefined) {
@@ -487,6 +498,9 @@ export function findClosestCheckpointState(
   cp: CheckpointHex,
   cache: Map<string, CachedBeaconStateAllForks | PersistentKey>
 ): CachedBeaconStateAllForks | null {
+  // LION: This function must handle checkpoints on different branches
+  // Just picking the state with the closest epoch does not work in really bad cases
+  // Must add unit tests for this
   let smallestEpochDiff = Infinity;
   let closestState: CachedBeaconStateAllForks | null = null;
   for (const [key, value] of cache.entries()) {
diff --git a/packages/state-transition/src/util/loadState.ts b/packages/state-transition/src/util/loadState.ts
index 18eac53e6f..5d6a096585 100644
--- a/packages/state-transition/src/util/loadState.ts
+++ b/packages/state-transition/src/util/loadState.ts
@@ -32,6 +32,7 @@ export function loadState(
   const fieldRanges = stateType.getFieldRanges(dataView, 0, stateBytes.length);
   const allFields = Object.keys(stateType.fields);
   const validatorsFieldIndex = allFields.indexOf("validators");
+  // This call for a mainnet state is not free, why is it necessary to initialize all vectors to zero?
   const migratedState = stateType.defaultViewDU();
   // validators is rarely changed
   const validatorsRange = fieldRanges[validatorsFieldIndex];
@@ -42,7 +43,9 @@ export function loadState(
   );
   // inactivityScores
   // this takes ~500 to hashTreeRoot while this field is rarely changed
+  // LION: 500 what? use units
   const fork = getForkFromStateBytes(config, stateBytes);
+  // rename to seedStateFork
   const seedFork = config.getForkSeq(seedState.slot);
 
   let loadedInactivityScores = false;